JavaScript 'Using' ifodasi: Resurslarni zamonaviy avtomatik yo'q qilish

JavaScript til sifatida paydo bo'lganidan beri sezilarli darajada rivojlandi. Zamonaviy JavaScript ishlanmalari toza, qo'llab-quvvatlanadigan va samarali kod yozishga urg'u beradi. Mustahkam ilovalarni yozishning muhim jihatlaridan biri bu resurslarni to'g'ri boshqarishdir. An'anaga ko'ra, JavaScript xotirani qaytarib olish uchun asosan axlat yig'ishga (garbage collection) tayangan, ammo bu jarayon deterministik emas, ya'ni xotira qachon bo'shatilishi aniq noma'lum. Bu xotira sizib chiqishi va ilovaning oldindan aytib bo'lmaydigan xatti-harakatlari kabi muammolarga olib kelishi mumkin. 'Using' ifodasi, tilga nisbatan yangi qo'shimcha bo'lib, resurslarni avtomatik yo'q qilish uchun kuchli mexanizmni taqdim etadi, bu esa resurslarning tez va ishonchli ravishda bo'shatilishini ta'minlaydi.

Nima uchun resurslarni avtomatik yo'q qilish muhim

Ko'pgina dasturlash tillarida dasturchilar resurslarni endi kerak bo'lmaganda aniq bo'shatish uchun mas'uldirlar. Bularga fayl tutqichlari (file handles), ma'lumotlar bazasi ulanishlari, tarmoq soketlari va xotira buferlari kiradi. Buni qilmaslik resurslarning tugashiga olib kelishi mumkin, bu esa ishlash samaradorligining pasayishiga va hatto ilovaning ishdan chiqishiga sabab bo'ladi. JavaScriptning axlat yig'uvchisi bu muammolarning ba'zilarini yumshatishga yordam bersa-da, bu mukammal yechim emas. Axlat yig'ish davriy ravishda ishlaydi va resurslarni darhol qaytarib olmasligi mumkin, ayniqsa ular kodning biror qismida hali ham havola qilinayotgan bo'lsa. Bu kechikish uzoq muddatli ilovalarda yoki katta hajmdagi ma'lumotlar bilan ishlaydigan ilovalarda ayniqsa muammoli.

Fayl bilan ishlayotgan stsenariyni ko'rib chiqing. Siz faylni ochasiz, uning tarkibini o'qiysiz va keyin yopasiz. Agar faylni yopishni unutsangiz, operatsion tizim faylni ochiq holda saqlashi mumkin, bu esa boshqa ilovalarning unga kirishini oldini oladi yoki hatto ma'lumotlarning buzilishiga olib keladi. Shunga o'xshash muammolar ma'lumotlar bazasi ulanishlarida ham paydo bo'lishi mumkin, bu yerda bo'sh ulanishlar qimmatli server resurslarini iste'mol qilishi mumkin. 'Using' ifodasi operatsiya davomida xatolik yuz berganidan qat'i nazar, bu resurslarning endi kerak bo'lmaganda doimo bo'shatilishini ta'minlashning tuzilmali usulini taqdim etadi.

'Using' ifodasi bilan tanishuv

'Using' ifodasi JavaScriptda resurslarni boshqarishni soddalashtiradigan til xususiyatidir. Bu sizga resurs ishlatiladigan doirani (scope) aniqlash imkonini beradi va ushbu doiradan chiqilganda, resurs avtomatik ravishda yo'q qilinadi. Bunga 'Symbol.dispose' va 'Symbol.asyncDispose' simvollari orqali erishiladi, ular 'using' ifodasi tugaganda chaqiriladigan usullarni aniqlaydi.

U qanday ishlaydi

'Using' ifodasi, 'using' ifodasi ichidagi kod bloki tugagandan so'ng, ob'ektning 'Symbol.dispose' yoki 'Symbol.asyncDispose' usulini chaqirishni ta'minlash orqali ishlaydi. Bu blok normal ravishda tugasa ham yoki istisno (exception) tufayli tugasa ham sodir bo'ladi. 'Using' ifodasidan foydalanish uchun siz foydalanayotgan ob'ekt 'Symbol.dispose' (sinxron yo'q qilish uchun) yoki 'Symbol.asyncDispose' (asinxron yo'q qilish uchun) usulini amalga oshirishi kerak. Ushbu usullar ob'ekt tomonidan ushlab turilgan resurslarni bo'shatish uchun mas'uldir.

'Using' ifodasining asosiy sintaksisi quyidagicha:

            using (resource) {
  // Resursdan foydalanadigan kod
}

            

              
                Copy
              
            
          

Bu yerda resource 'Symbol.dispose' yoki 'Symbol.asyncDispose' usulini amalga oshiradigan ob'ektdir. Jingalak qavslar ichidagi kod resurs ishlatiladigan doiradir. Kod bajarilishi ushbu doiradan chiqqanda (blok oxiriga yetganda yoki istisno tashlaganda), resource ob'ektining 'Symbol.dispose' yoki 'Symbol.asyncDispose' usuli avtomatik ravishda chaqiriladi.

Symbol.dispose yordamida sinxron yo'q qilish

Sinxron ravishda yo'q qilinishi mumkin bo'lgan resurslar uchun siz 'Symbol.dispose' simvolidan foydalanishingiz mumkin. Bu simvol kerakli tozalash operatsiyalarini bajaradigan usulni aniqlaydi. Mana bir misol:

            class FileResource {
  constructor(filename) {
    this.filename = filename;
    this.fileHandle = fs.openSync(filename, 'r+');
    console.log(`${filename} fayli ochildi.`);
  }

  [Symbol.dispose]() {
    fs.closeSync(this.fileHandle);
    console.log(`${this.filename} fayli yopildi.`);
  }

  readSync(buffer, offset, length, position) {
    return fs.readSync(this.fileHandle, buffer, offset, length, position);
  }
}

const fs = require('node:fs');

try (const file = new FileResource('example.txt')) {
  const buffer = Buffer.alloc(1024);
  const bytesRead = file.readSync(buffer, 0, buffer.length, 0);
  console.log(`Fayldan ${bytesRead} bayt o'qildi.`);
  console.log(buffer.toString('utf8', 0, bytesRead));
} catch (err) {
  console.error('Xatolik yuz berdi:', err);
}

            

              
                Copy
              
            
          

Ushbu misolda FileResource klassi fayl resursini ifodalaydi. Konstruktor faylni ochadi, va 'Symbol.dispose' usuli uni yopadi. 'Using' ifodasi blokdan chiqilganda faylning avtomatik yopilishini ta'minlaydi. Agar 'try' bloki ichida biron bir xatolik yuz bersa ham, fayl 'using' ifodasi tufayli baribir yopiladi, bu esa resurs sizib chiqishining oldini oladi.

Tushuntirish: `FileResource` klassi fayl resursini simulyatsiya qiladi. `[Symbol.dispose]()` usuli `fs.closeSync()` yordamida faylni sinxron ravishda yopish mantig'ini o'z ichiga oladi. `try...using` bloki, istisno tashlanganligidan qat'i nazar, blokdan chiqilganda `[Symbol.dispose]()` chaqirilishini kafolatlaydi. Bu faylning har doim yopilishini ta'minlaydi.

Symbol.asyncDispose yordamida asinxron yo'q qilish

Tarmoq yoki ma'lumotlar bazasi ulanishlari kabi asinxron yo'q qilishni talab qiladigan resurslar uchun 'Symbol.asyncDispose' simvolidan foydalanishingiz mumkin. Bu simvol tozalash operatsiyalarini bajaradigan asinxron usulni aniqlaydi. Mana taxminiy ma'lumotlar bazasi ulanishidan foydalangan holda misol:

            class DatabaseConnection {
  constructor(connectionString) {
    this.connectionString = connectionString;
    this.connection = null;
  }

  async connect() {
    // Ma'lumotlar bazasiga ulanishni simulyatsiya qilish
    return new Promise(resolve => {
      setTimeout(() => {
        this.connection = { id: Math.random() }; // Ulanish ob'ektini simulyatsiya qilish
        console.log(`Ma'lumotlar bazasiga ulandi: ${this.connectionString}`);
        resolve();
      }, 500);
    });
  }

  async query(sql) {
    // So'rovni bajarishni simulyatsiya qilish
    return new Promise(resolve => {
      setTimeout(() => {
        console.log(`So'rov bajarilmoqda: ${sql}`);
        resolve([{ result: 'some data' }]); // So'rov natijalarini simulyatsiya qilish
      }, 200);
    });
  }

  async [Symbol.asyncDispose]() {
    // Ma'lumotlar bazasi ulanishini yopishni simulyatsiya qilish
    return new Promise(resolve => {
      setTimeout(() => {
        console.log(`Ma'lumotlar bazasi ulanishi yopilmoqda: ${this.connectionString}`);
        this.connection = null;
        resolve();
      }, 300);
    });
  }
}

async function main() {
  const connectionString = 'mongodb://localhost:27017/mydatabase';
  try {
    await using db = new DatabaseConnection(connectionString);
    await db.connect();
    const results = await db.query('SELECT * FROM users');
    console.log('So'rov natijalari:', results);
  } catch (err) {
    console.error('Xatolik yuz berdi:', err);
  }
}

main();

            

              
                Copy
              
            
          

Ushbu misolda DatabaseConnection klassi ma'lumotlar bazasi ulanishini ifodalaydi. Konstruktor ulanish satrini ishga tushiradi va 'Symbol.asyncDispose' usuli ulanishni asinxron ravishda yopadi. 'Await using' ifodasi blokdan chiqilganda ulanishning avtomatik ravishda yopilishini ta'minlaydi. Yana bir bor, ma'lumotlar bazasi operatsiyasi davomida xatolik yuz bersa ham, ulanish baribir yopiladi, bu esa resurs sizib chiqishining oldini oladi. `connect` va `query` usullari asinxron bo'lib, real dunyodagi ma'lumotlar bazasi operatsiyalarini simulyatsiya qiladi.

Tushuntirish: `DatabaseConnection` klassi asinxron ma'lumotlar bazasi ulanishini simulyatsiya qiladi. `[Symbol.asyncDispose]()` usuli asinxron funksiya sifatida aniqlangan bo'lib, odatda asinxron operatsiyalarni o'z ichiga oladigan ma'lumotlar bazasi ulanishini yopishni simulyatsiya qiladi. `await using` bloki blokdan chiqqanda `[Symbol.asyncDispose]()` usulining asinxron ravishda chaqirilishini ta'minlaydi va ma'lumotlar bazasi ulanishini tozalaydi. Simulyatsiya asinxron resurslarni tozalash qanday boshqarilishini ko'rsatishga yordam beradi.

Yashirin va Aniq 'Using' e'lonlari

'Using' ifodasi ikkita asosiy shaklga ega: yashirin va aniq. Yuqoridagi misollar asosan aniq e'lonlarni ko'rsatdi.

Aniq 'Using'

Misollarda ko'rinib turganidek, aniq e'lonlar `using` qavslari ichida e'lon qilinayotgan o'zgaruvchidan oldin `const` kalit so'zini talab qiladi (yoki asinxron yo'q qilish uchun `await` dan keyin `const`). Bu resursning faqat `using` bloki doirasida bo'lishini ta'minlaydi. Ushbu blokdan tashqarida resursdan foydalanishga urinish xatolikka olib keladi. Bu resursning umrini qat'iyroq cheklaydi, bu esa kod xavfsizligini oshiradi va noto'g'ri foydalanish ehtimolini kamaytiradi. Aniq 'using' e'lonnomasi blokdan chiqqanda resursning yo'q qilinishini juda aniq ko'rsatadi.

            try (const file = new FileResource('example.txt')) {
  // Fayl resursidan bu yerda foydalaning
}
// file bu yerda endi mavjud emas; 'file' dan foydalanishga urinish xatolikka olib keladi

            

              
                Copy
              
            
          

Yashirin 'Using'

Yashirin 'using' e'lonlari esa resursni *tashqi doiraga* bog'laydi. Bunga `const` kalit so'zini *tushirib qoldirish* orqali erishiladi. Bu qulay tuyulishi mumkin bo'lsa-da, odatda tavsiya etilmaydi, chunki bu chalkashlikka va resurs yo'q qilinganidan keyin tasodifan noto'g'ri foydalanishga olib kelishi mumkin. Yashirin e'lon bilan, `using` ifodasida e'lon qilingan o'zgaruvchi `using` blokidan tashqarida ham mavjud bo'lib qoladi, garchi u ushlab turgan resurs yo'q qilingan bo'lsa ham. Agar kod yo'q qilingan resursdan foydalanishga urinsa, bu ish vaqtidagi xatoliklarga olib kelishi mumkin.

            let file;
try (file = new FileResource('example.txt')) {
  // Fayl resursidan bu yerda foydalaning
}
// file bu yerda hali ham mavjud, lekin u ushlab turgan resurs yo'q qilingan!
// Bu yerda 'file' dan foydalanish xatolikka yoki kutilmagan xatti-harakatga olib kelishi mumkin.

            

              
                Copy
              
            
          

Kodning aniqligini oshirish va yo'q qilingan resurslarga tasodifiy kirishni oldini olish uchun aniq `using` e'lonlaridan (`const`) foydalanish qat'iy tavsiya etiladi.

'Using' ifodasidan foydalanishning afzalliklari

• Resurslarni avtomatik yo'q qilish: Resurslar endi kerak bo'lmaganda doimo bo'shatilishini ta'minlaydi, bu esa resurs sizib chiqishining oldini oladi va ilova ishonchliligini oshiradi.
• Soddalashtirilgan kod: Resurslarni boshqarish uchun zarur bo'lgan shablon kod miqdorini kamaytiradi, bu kodni toza va tushunarli qiladi. Tozalash uchun `try...finally` bloklariga ehtiyoj yo'q.
• Xatoliklarni yaxshiroq qayta ishlash: Istisnolar yuzaga kelganda ham resurslarni yo'q qilishni avtomatik ravishda boshqaradi, bu esa operatsiya natijasidan qat'i nazar, resurslarning doimo bo'shatilishini ta'minlaydi.
• Deterministik yo'q qilish: Faqat axlat yig'ishga tayanish bilan solishtirganda resurslarni boshqarishning ancha deterministik usulini ta'minlaydi. Axlat yig'ish hali ham muhim bo'lsa-da, 'using' ifodasi resurslar qachon bo'shatilishi ustidan ko'proq nazoratni beradi.
• Kod xavfsizligini oshirish: Resurslarning to'g'ri yo'q qilinishini va 'using' bloki tugagandan so'ng (aniq e'lonlar bilan) ularga kirish imkoni bo'lmasligini ta'minlab, ulardan tasodifan noto'g'ri foydalanishning oldini oladi.

'Using' ifodasi uchun foydalanish holatlari

'Using' ifodasi resurslarni boshqarish muhim bo'lgan keng ko'lamli stsenariylarda qo'llaniladi. Mana bir nechta umumiy foydalanish holatlari:

• Fayllar bilan ishlash: Fayllar ishlatilgandan so'ng doimo yopilishini ta'minlaydi, bu fayl buzilishi va resurslarning tugashini oldini oladi.
• Ma'lumotlar bazasi ulanishlari: Endi kerak bo'lmaganda ma'lumotlar bazasi ulanishlarini yopadi, server resurslarini bo'shatadi va ishlash samaradorligini oshiradi.
• Tarmoq soketlari: Resurs sizib chiqishini oldini olish va ulanishlarning to'g'ri tugatilishini ta'minlash uchun tarmoq soketlarini yopadi.
• Xotira buferlari: Endi kerak bo'lmaganda xotira buferlarini bo'shatadi, xotira sizib chiqishini oldini oladi va ilova samaradorligini oshiradi.
• Audio/Video oqimlari: Oqimlarni yopadi, tizim resurslarini bo'shatadi va potentsial ma'lumotlar buzilishining oldini oladi.
• Grafik resurslar: Veb-ilovalarda teksturalar va shaderlar kabi grafik resurslarni bo'shatadi.

Turli sohalardan misollar:

• Moliyaviy xizmatlar: Yuqori chastotali savdo ilovalarida 'using' ifodasi tarmoq soketlari va ma'lumotlar oqimlarini samarali boshqarish uchun ishlatilishi mumkin, bu esa ishlashni saqlab qolish uchun resurslarning tezda bo'shatilishini ta'minlaydi.
• Sog'liqni saqlash: Tibbiy tasvirlash ilovalarida 'using' ifodasi katta tasvir fayllari va xotira buferlarini boshqarish uchun ishlatilishi mumkin, bu esa xotira sizib chiqishining oldini oladi va resurslar endi kerak bo'lmaganda bo'shatilishini ta'minlaydi.
• Elektron tijorat: Elektron tijorat platformalarida 'using' ifodasi ma'lumotlar bazasi ulanishlari va tranzaksiya resurslarini boshqarish uchun ishlatilishi mumkin, bu esa ma'lumotlar barqarorligini ta'minlaydi va resurslarning tugashini oldini oladi.

'Using' ifodasidan foydalanish bo'yicha eng yaxshi amaliyotlar

'Using' ifodasidan maksimal darajada foydalanish uchun quyidagi eng yaxshi amaliyotlarni hisobga oling:

• Har doim aniq e'lonlardan foydalaning: Resurslarning faqat 'using' bloki doirasida bo'lishini ta'minlash uchun aniq 'using' e'lonlaridan (`const`) foydalaning, bu esa tasodifiy noto'g'ri foydalanishning oldini oladi va kodning aniqligini oshiradi.
• Dispose usullarini to'g'ri amalga oshiring: 'Symbol.dispose' yoki 'Symbol.asyncDispose' usullarining to'g'ri amalga oshirilganligiga, ob'ekt tomonidan ushlab turilgan barcha resurslarni to'g'ri bo'shatilishiga ishonch hosil qiling. Istisnolarning tarqalishini oldini olish uchun ushbu usullar ichidagi potentsial xatoliklarni qayta ishlang.
• Uzoq muddatli resurslardan saqlaning: Resurs sizib chiqishi potentsialini kamaytirish uchun resurslarning ishlash muddatini minimallashtiring. Resurslar endi kerak bo'lmaganda darhol bo'shatilishini ta'minlash uchun 'using' ifodasidan foydalaning.
• Kodingizni sinchkovlik bilan sinab ko'ring: Resurslarning to'g'ri yo'q qilinayotganiga ishonch hosil qilish uchun kodingizni sinchkovlik bilan sinab ko'ring. Har qanday resurs sizib chiqishini aniqlash va tuzatish uchun xotirani profillash vositalaridan foydalaning.
• Ichma-ich 'using' ifodalarini ko'rib chiqing: Bir nechta resurslar bilan ishlaganda, resurslarning to'g'ri tartibda bo'shatilishini ta'minlash uchun ichma-ich 'using' ifodalaridan foydalanishni ko'rib chiqing.
• Istisnolarni qayta ishlang: 'Using' istisnolarda yo'q qilishni boshqarsa-da, resursdan foydalanadigan kod blokingiz ichida istisnolarni to'g'ri qayta ishlashni ta'minlang. Bu ishlov berilmagan rad etishlarning oldini oladi.
• Resurs boshqaruvini hujjatlashtiring: Qaysi klasslar resurslarni boshqarishini va 'using' ifodasi qanday qo'llanilishi kerakligini aniq hujjatlashtiring.

Brauzer va Node.js qo'llab-quvvatlashi

'Using' ifodasi JavaScriptdagi nisbatan yangi xususiyatdir. Ushbu maqola yozilayotgan vaqtda (2024), u TC39 4-bosqich taklifining bir qismi bo'lib, zamonaviy brauzerlar va Node.js da qo'llab-quvvatlanadi. Biroq, eski brauzerlar yoki Node.js versiyalari uni qo'llab-quvvatlamasligi mumkin. Kodingiz eski muhitlarda to'g'ri ishlashini ta'minlash uchun Babel kabi transpilyatordan foydalanishingiz kerak bo'lishi mumkin.

Brauzerlarni qo'llab-quvvatlash: Chrome, Firefox, Safari va Edge'ning zamonaviy versiyalari odatda 'using' ifodasini qo'llab-quvvatlaydi. Eng so'nggi ma'lumotlar uchun MDN Web Docs kabi muvofiqlik jadvallarini tekshiring.

Node.js qo'llab-quvvatlashi: Node.js 16 va undan keyingi versiyalari 'using' ifodasini qo'llab-quvvatlaydi. Node.js versiyangiz yangilanganligiga ishonch hosil qiling.

'Using' ifodasiga alternativlar

'Using' ifodasi joriy etilishidan oldin, dasturchilar odatda resurslarning bo'shatilishini ta'minlash uchun 'try...finally' bloklariga tayanishgan. Bu yondashuv hali ham amalda bo'lsa-da, 'using' ifodasiga nisbatan ko'proq so'zli va xatoliklarga moyil. Mana bir misol:

            let file;
try {
  file = new FileResource('example.txt');
  // Fayl resursidan bu yerda foydalaning
} catch (err) {
  console.error('Xatolik yuz berdi:', err);
} finally {
  if (file) {
    file[Symbol.dispose]();
  }
}

            

              
                Copy
              
            
          

'Try...finally' bloki sizdan resurs mavjudligini qo'lda tekshirishni va keyin yo'q qilish usulini chaqirishni talab qiladi. Bu, ayniqsa, bir nechta resurslar bilan ishlaganda noqulay bo'lishi mumkin. 'Using' ifodasi resursni yo'q qilishni avtomatlashtirish orqali bu jarayonni soddalashtiradi, kodni toza va qo'llab-quvvatlashni osonlashtiradi.

Boshqa alternativlar resurslarni boshqarish kutubxonalari yoki naqshlarini o'z ichiga oladi, ammo bular ko'pincha loyihaga murakkablik qo'shadi. `using` ifodasi ham oqlangan, ham samarali bo'lgan o'rnatilgan til darajasidagi yechimni taqdim etadi.

Xulosa

JavaScriptning 'using' ifodasi resurslarni avtomatik yo'q qilish uchun kuchli vosita bo'lib, dasturchilarga toza, ishonchliroq va samaraliroq kod yozishga yordam beradi. Resurslar endi kerak bo'lmaganda doimo bo'shatilishini ta'minlash orqali, 'using' ifodasi resurs sizib chiqishining oldini oladi, xatoliklarni qayta ishlashni yaxshilaydi va kodni qo'llab-quvvatlashni soddalashtiradi. JavaScript rivojlanishda davom etar ekan, 'using' ifodasi zamonaviy veb-ishlanmalarning tobora muhimroq qismiga aylanib borishi mumkin. Yaxshiroq JavaScript kodi yozish uchun uni qabul qiling!

Qo'shimcha o'rganish uchun

• TC39 takliflari: Eng so'nggi o'zgarishlardan xabardor bo'lish uchun 'using' ifodasi bo'yicha TC39 takliflarini kuzatib boring.
• MDN Web Docs: 'Using' ifodasi va uning ishlatilishi haqida keng qamrovli hujjatlar uchun MDN Web Docs-ga murojaat qiling.
• Onlayn darsliklar va misollar: 'Using' ifodasi bilan amaliy tajriba orttirish uchun onlayn darsliklar va misollarni o'rganing.